package com.wfk.utils;

import java.math.BigDecimal;
import java.nio.ByteBuffer;
import java.util.Objects;

import javax.servlet.http.HttpServletRequest;

import cn.hutool.setting.dialect.Props;

public class ValidateUtil {
	
    /**
     * 验证输入的数据是否为空
     * @param data 输入数据
     * @return 如果不是null返回true，否则返回false
     */
    public static boolean empty(String data) {
        if (data == null || "".equals(data)) {
            return false ;
        }
        return true ;
    }

    /**
     * 进行数据的正则操作验证
     * @param data 要验证的数据
     * @param regex 要执行验证的正则表达式
     * @return 如果验证通过返回true，否则返回false
     */
    public static boolean regex(String data,String regex) {
        if (empty(data)) { // 数据不为空
            return data.matches(regex) ;    // 验证验证
        }
        return false ;
    }

    /**
     * 验证两个数据是否相同，不区分大小写
     * @param dataa 数据一
     * @param datab 数据二
     * @return 如果相同返回true，否则返回false
     */
    public static boolean same(String dataa,String datab) {
        if (empty(dataa) && empty(datab)) {
            return dataa.equalsIgnoreCase(datab) ;
        }
        return false ;
    }
    
    /**
     * 验证两个数据是否相同
     * @param dataa 数据一
     * @param datab 数据二
     * @return 如果相同返回true，否则返回false
     */
    public static boolean equalTo(String dataa,String datab) {
        if (empty(dataa) && empty(datab)) {
            return dataa.equals(datab) ;
        }
        return false ;
    }
    
    
    /**
	 * 验证字符串是否是日期类型或者是日期事件类型
	 * 
	 * @param str
	 *            要验证的内容
	 * @return 如果字符串是日期或者是日期时间，则返回true，否则返回false
	 */
	public static boolean date(String str) {
		if (empty(str)) {
			if (str.matches("\\d{4}-\\d{2}-\\d{2}")) {
				return true;
			} else { // 有可能是日期时间类型
				if (str.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}")) {
					return true ;
				} else {
					return str.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{1,3}");
				}
			}
		}
		return false;
	}
    
	/**
	 * 进行数字的验证操作，验证之前首先要判断数据是否为空
	 * 
	 * @param str
	 *            要验证的内容
	 * @return 如果是由数字所组成返回true，否则返回false
	 */
	public static boolean validateInt(String str) {
		if (empty(str)) { // 首先判断数据是否合法
			return str.matches("\\d+");
		}
		return false;
	}
	
	/**
	 * 进行小数的验证操作，验证之前要先判断数据是否为空
	 * 
	 * @param str
	 *            要验证的内容
	 * @return 如果字符串由小数所组成返回true，否则返回false
	 */
	public static boolean validateDouble(String str) {
		if (empty(str)) {
			return str.matches("\\d+(\\.\\d+)?");
		}
		return false;
	}
	/**
	 * 进行判断是否大于0
	 * @param data
	 * @return
	 */
	public static boolean sign(String data){
		if (empty(data)) {
			return new BigDecimal(data.substring(0, data.length()-1)).compareTo(BigDecimal.ZERO)>0;
		}
		return false;
	}
	
	/**
	 * 判断两个int类型的是否相等
	 * @param a data1
	 * @param b data2
	 * @return 如果相等返回true否则false
	 */
	public static boolean isEquals(Integer a, Integer b) {
		if (a == null) {
			if (b.equals(a) || b == a) {
				return true;
			}
		} else {
			if (a.equals(b) || b == a) {
				return true;
			}
		}
		return false;
	}
	
	/**
	 * 判断一个对象是否为空
	 * @param object data
	 * @return 如果对象为null返回true否则返回false
	 */
	public static boolean objEmpty(Object object){
		return Objects.isNull(object);
	}
	
	public static boolean validate(HttpServletRequest request, String rule) {
	        boolean flag = true;
	        String[] result = rule.split("\\|");
	        for (int x = 0; x < result.length; x++) {
	            String temp[] = result[x].split(":");
	            String value = request.getParameter(temp[0]);// 取得参数内容
	            if (value != null) {
	                if ("String".equals(temp[1])) {
	                    flag = empty(value);
	                } else if ("Integer".equals(temp[1])) {
	                    flag = validateInt(value);
	                } else if ("BigDecimal".equals(temp[1])) {
	                    flag = validateDouble(value);
	                } else if("Date".equals(temp[1])){
	                	flag = date(value);
	                }
	                if (flag == false) { // 传递错误信息
	                    request.setAttribute("ruleError",
	                    		temp[1]+new Props("sanxin/messages.properties").getProperty(temp[0]+".validate.error.msg"));
	                    return flag;
	                }
	            }else {
	                flag = false;
	                request.setAttribute("valueError",temp[0]+"参数信息不正确");
	                return flag;
	            }
	        }
	        return flag;
	    }
}
